package com.atguigu.tingshu.album.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.atguigu.tingshu.album.mapper.AlbumInfoMapper;
import com.atguigu.tingshu.album.mapper.AlbumStatMapper;
import com.atguigu.tingshu.album.mapper.TrackInfoMapper;
import com.atguigu.tingshu.album.service.AlbumAttributeValueService;
import com.atguigu.tingshu.album.service.AlbumInfoService;
import com.atguigu.tingshu.album.service.AuditService;
import com.atguigu.tingshu.common.cache.DataCache;
import com.atguigu.tingshu.common.constant.RedisConstant;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.execption.GuiguException;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.common.util.AuthContextHolder;
import com.atguigu.tingshu.model.album.AlbumAttributeValue;
import com.atguigu.tingshu.model.album.AlbumInfo;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.atguigu.tingshu.model.album.TrackInfo;
import com.atguigu.tingshu.query.album.*;
import com.atguigu.tingshu.query.album.AlbumInfoVo;
import com.atguigu.tingshu.query.album.AlbumStatVo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Service
@SuppressWarnings({"all"})
public class AlbumInfoServiceImpl extends ServiceImpl<AlbumInfoMapper, AlbumInfo> implements AlbumInfoService {

    @Autowired
    private AlbumInfoMapper albumInfoMapper;
    @Autowired
    private AlbumAttributeValueService albumAttributeValueService;
    @Autowired
    private AlbumStatMapper albumStatMapper;
    @Autowired
    private AuditService auditService;
    @Autowired
    private TrackInfoMapper trackInfoMapper;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private RabbitService rabbitService;

    /**
     * 保存专辑信息
     *
     * @param albumInfoVo 专辑Vo信息,可对请求参数进行校验
     * @param userID      用户ID,可从线程中获取
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveAlbumInfo(AlbumInfoVo albumInfoVo, Long userId) {
        //1 将专辑VO视图对象转为PO对象
        //使用hutool工具包中的对象转换工具
        AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
        //2 封装专辑PO对象中所需userID,免费试听集数,专辑状态等参数
        albumInfo.setUserId(userId);
        albumInfo.setTracksForFree(5);        //免费试听五集,暂时硬编程,可配置
        albumInfo.setStatus(SystemConstant.ALBUM_STATUS_NO_PASS);        //审核状态,尚未审核
        albumInfoMapper.insert(albumInfo);
        Long albumId = albumInfo.getId();
        System.out.println(albumId + "添加albumInfo回显id----------------------------");
        //3 保存专辑标签信息
        //专辑标签表结构为专辑表(1)->(n)标签表
        //标签VO对象转为标签PO对象
        List<AlbumAttributeValueVo> albumAttributeValueVoList = albumInfoVo.getAlbumAttributeValueVoList();
        saveAlbumAttributeValueList(albumId, albumAttributeValueVoList);
        //4 保存专辑统计信息
        saveAlbumInfoStat(albumId, SystemConstant.ALBUM_STAT_PLAY, 0);
        saveAlbumInfoStat(albumId, SystemConstant.ALBUM_STAT_BUY, 0);
        saveAlbumInfoStat(albumId, SystemConstant.ALBUM_STAT_COMMENT, 0);
        saveAlbumInfoStat(albumId, SystemConstant.ALBUM_STAT_SUBSCRIBE, 0);

//        服务暂停  //对专辑文本内容(标题,简介等内容)进行审核
//        String conText = albumInfo.getAlbumTitle() + albumInfo.getAlbumIntro();
//        String suggestion = auditService.auditText(conText);
//        if ("pass".equals(suggestion)) {
//            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
//            //使用RabbitMQ发送专辑上架消息
//            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER, albumInfo.getId());
//        } else if ("block".equals(suggestion)) {
//            //使用RabbitMQ发送专辑下架消息
//            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_NO_PASS);
//            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,albumInfo.getId());
//        } else if ("review".equals(suggestion)) {
//            //使用RabbitMQ发送专辑下架消息
//            albumInfo.setStatus(SystemConstant.TRACK_STATUS_REVIEWING);
//            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,albumInfo.getId());
//        }
        albumInfoMapper.updateById(albumInfo);
    }

    public void saveAlbumInfoStat(Long albumId, String statType, int statNum) {
        AlbumStat albumStat = new AlbumStat();
        albumStat.setAlbumId(albumId);
        albumStat.setStatType(statType);
        albumStat.setStatNum(statNum);
        albumStatMapper.insert(albumStat);
    }

    /**
     * 查看当前用户专辑分页列表
     *
     * @param albumListVoIPage 分页请求集合(结果对象包含AlbumInfo内容及Albumstat内容,需拼接结果集)
     * @param albumInfoQuery   请求条件对象(标题: 需支持模糊查询,状态,用户ID)
     */
    @Override
    public IPage<AlbumListVo> findUserAlbumPage(IPage<AlbumListVo> albumListVoIPage, AlbumInfoQuery albumInfoQuery) {
        Long userId = AuthContextHolder.getUserId();
        albumInfoQuery.setUserId(userId);
        albumListVoIPage = albumInfoMapper.findUserAlbumPage(albumListVoIPage, albumInfoQuery);
        return albumListVoIPage;
    }

    /**
     * 删除专辑内容
     *
     * @param id 待删除专辑ID
     * @业务需求: 专辑栏下有声音信息, 不可删除, 若为空, 可执行删除, 并一并清理标签表, 声音表和统计信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void removeAlbumInfo(Long id) {

        //无需查询全部声音内容,只需统计声音信息行数
        Long trackCount = trackInfoMapper.selectCount(new LambdaQueryWrapper<TrackInfo>().eq(TrackInfo::getAlbumId, id));
        if (trackCount > 0) {
            throw new GuiguException(500, "专辑中声音,请勿删除");
        }
        //删除专辑表内容
        albumInfoMapper.deleteById(id);
        //删除统计关联表内容
        albumStatMapper.delete(new LambdaQueryWrapper<AlbumStat>().eq(AlbumStat::getAlbumId, id));
        //删除标签关联表内容
        albumAttributeValueService.remove(new LambdaQueryWrapper<AlbumAttributeValue>().eq(AlbumAttributeValue::getAlbumId, id));

        rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
    }

    /**
     * 修改专辑信息
     *
     * @param id          待修改专辑id
     * @param albumInfoVo 待修改专辑信息内容视图对象
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateAlbumInfo(Long id, AlbumInfoVo albumInfoVo) {
        //将VO数据封装至PO对象中
        AlbumInfo albumInfo = BeanUtil.copyProperties(albumInfoVo, AlbumInfo.class);
        albumInfo.setId(id);
//        服务暂停  //更新后文本校验
//        String conText = albumInfo.getAlbumTitle()+albumInfo.getAlbumIntro();
//        String suggestion = auditService.auditText(conText);
//        if ("pass".equals(suggestion)) {
//            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_PASS);
//            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_UPPER, id);
//        } else if ("block".equals(suggestion)) {
//            albumInfo.setStatus(SystemConstant.ALBUM_STATUS_NO_PASS);
//            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
//        } else if ("review".equals(suggestion)) {
//            albumInfo.setStatus(SystemConstant.TRACK_STATUS_REVIEWING);
//            rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_ALBUM_LOWER,id);
//        }
        albumInfoMapper.updateById(albumInfo);
        //更新标签关联表
        //更新逻辑: 删除原有标签表内容,若修改包含标签信息,重新添加
        saveAlbumAttributeValueList(id, albumInfoVo.getAlbumAttributeValueVoList());
    }

    /**
     * 根据ID获取当前专辑统计信息
     *
     * @param albumId 当前专辑ID
     */
    @Override
    @DataCache(prefix = RedisConstant.ALBUM_INFO_PREFIX+":stat:")
    public AlbumStatVo getAlbumStatVo(Long albumId) {
        AlbumStatVo albumStatVo = albumStatMapper.getAlbumStatVo(albumId);
        return albumStatVo;
    }

    /**
     * 获取当前用户所有专辑列表
     *
     * @param userId 当前登录用户ID
     */
    @Override
    public List<AlbumInfo> findUserAllAlbumList(Long userId) {
        //1.构建查询条件QueryWrapper对象
        LambdaQueryWrapper<AlbumInfo> queryWrapper = new LambdaQueryWrapper<>();
        //1.1 查询条件
        queryWrapper.eq(AlbumInfo::getUserId, userId);
        //1.2 排序
        queryWrapper.orderByDesc(AlbumInfo::getId);
        //1.3 限制记录数
        queryWrapper.last("LIMIT 200");
        //1.4 指定查询列
        queryWrapper.select(AlbumInfo::getId, AlbumInfo::getAlbumTitle);
        //2.执行列表查询
        return albumInfoMapper.selectList(queryWrapper);
    }

    /**
     * 保存专辑所含标签信息
     *
     * @param albumId                   专辑ID
     * @param albumAttributeValueVoList 标签信息VO对象List
     */
    public void saveAlbumAttributeValueList(Long albumId, List<AlbumAttributeValueVo> albumAttributeValueVoList) {
        albumAttributeValueService.removeById(albumId);
        if (CollUtil.isNotEmpty(albumAttributeValueVoList)) {
            //若标签集合非空,执行添加准备工作->转换对象
            List<AlbumAttributeValue> albumAttributeValueList = albumAttributeValueVoList.stream().map(albumAttributeVo -> {
                AlbumAttributeValue albumAttributeValue = BeanUtil.copyProperties(albumAttributeVo, AlbumAttributeValue.class);
                //补充标签与专辑关联字段
                albumAttributeValue.setAlbumId(albumId);
                return albumAttributeValue;
            }).collect(Collectors.toList());
            //调用标签服务层,可调用批量保存方法
            albumAttributeValueService.saveBatch(albumAttributeValueList);
        }
    }
}
